home *** CD-ROM | disk | FTP | other *** search
/ Die Speccy' 97 / Die Speccy' 97.iso / amiga_system / the_aminet / comm / bbs / s342q07.lha / aff.c < prev    next >
C/C++ Source or Header  |  1994-11-15  |  10KB  |  450 lines
  1. /*
  2.  *                Aff.C
  3.  *
  4.  * Automatic File Forwarding utility.
  5.  */
  6.  
  7. /*
  8.  *                History
  9.  *
  10.  * 90May15  HAW V1 Created.
  11.  */
  12.  
  13. /*
  14.  *                Contents
  15.  *
  16.  *    crashout()        general crash routine
  17.  *    InitSystem()        open up appropriate data base files
  18.  *    main()            main manager
  19.  *    ParseFileMap()        reads in CtdlAff.Sys
  20.  *    EatMapLine()        eats a line from a file map
  21.  *    RewriteFileMap()    writes out the updated file map
  22.  *    WriteFileList()        work fn that writes out a ctdlaff.sys entry
  23.  *    SystemWrite()        work fn writes out the indicated system
  24.  *    SendThemFiles()        setts up the .sfl files
  25.  *    UpdateSFLs()        updates the sfl file for the given system
  26.  *    WriteSFL()        This will write the .sfl file
  27.  *    CopyToTemp()        copies a name to the temporary list
  28.  *    ShowArguments()        usage
  29.  *    FileCmp()        helps find the string in a list
  30.  *    CheckSystems()        used to help search for a given system in list
  31.  */
  32.  
  33. #include "ctdl.h"
  34. #include <stdio.h>
  35. #include <string.h>
  36. #include <stdlib.h>
  37. #include <math.h>
  38. #include <ctype.h>
  39. #include <time.h>
  40. #include <dos.h>
  41. #include <proto/exec.h>
  42. #include <dos/dos.h>
  43. #include <pragmas/dos_pragmas.h>
  44. #include "exec/memory.h"
  45. #include "exec/ports.h"
  46. #include "exec/exec.h"
  47.  
  48. #ifndef NO_STAT
  49. #include "sys\stat.h"
  50. #endif
  51.  
  52. long getdateof(char *file);
  53.  
  54. extern FILE *upfd;
  55.  
  56. extern CONFIG    cfg;
  57. extern NetBuffer netBuf;
  58. extern int       thisNet;
  59. extern FILE      *netfl;
  60. extern NetTable  *netTab;
  61. extern char      *READ_ANY, *WRITE_ANY, *WRITE_TEXT;
  62.  
  63. void InitSystem(void);
  64. void ShowArguments(void);
  65. void ParseFileMap(void);
  66. void SendThemFiles(void);
  67. void RewriteFileMap(void);
  68.  
  69. /*
  70.  * crashout()
  71.  *
  72.  * This is general crash routine.  Needed by getNet, etc.
  73.  */
  74. void crashout(str)
  75. char *str;
  76. {
  77.     printf(str);
  78.     exit(1);
  79. }
  80.  
  81. /*
  82.  * InitSystem()
  83.  *
  84.  * This is used to open up appropriate data base files, and initialize buffers.
  85.  */
  86. void InitSystem()
  87. {
  88.     SYS_FILE name;
  89.  
  90.     /* Open database files. */
  91.     makeSysName(name, "ctdlnet.sys", &cfg.netArea);
  92.     openFile(name, &netfl);
  93.  
  94.     /* Now initialize data buffers. */
  95.     initNetBuf(&netBuf);
  96. }
  97.  
  98. /*
  99.  * main()
  100.  *
  101.  * The main manager for Aff.
  102.  */
  103. int main(int, char **);
  104. int main(argc, argv)
  105. int  argc;
  106. char **argv;
  107. {
  108.  
  109.     printf("AFF V1.3\nAutomatic File Forwarding\n%s\n", COPYRIGHT);
  110.  
  111.     if (access(LOCKFILE, 0) != ERROR) {
  112.     printf("Please do not run AFF using Outside Commands.\n");
  113.     exit(1);
  114.     }
  115.  
  116.     if (argc > 1) {
  117.     ShowArguments();
  118.     exit(1);
  119.     }
  120.  
  121.     if (!readSysTab(FALSE, FALSE)) {
  122.     printf("Couldn't read system table.\n");
  123.     exit(1);
  124.     }
  125.  
  126.     InitSystem();       /* Open needed data files       */
  127.  
  128.     ParseFileMap();
  129.  
  130.     RewriteFileMap();    /* rewrite updated CtdlAff.Sys next    */
  131.  
  132.     SendThemFiles();    /* now send them files (if any)     */
  133.  
  134.     writeSysTab();
  135.  
  136.     return 0;
  137. }
  138.  
  139. #define FILE_NAME    0
  140. #define SYSTEM_NAME    1
  141. #define NO_FILE_NAME    2
  142.  
  143. char MapState = FILE_NAME;
  144. void *EatMapLine(char *line);
  145. void *CheckSystems();
  146. SListBase Files = { NULL, NULL, NULL, NULL, EatMapLine };
  147. SListBase Systems = { NULL, CheckSystems, NULL, NULL, NULL };
  148.  
  149. /* this structure is used to rebuild ctdlaff.sys */
  150. typedef struct {
  151.     char *Filename;
  152.     long Date;
  153.     SListBase SystemList;
  154. } FileList;
  155.  
  156. /* this structure is used in SystemList, above */
  157. typedef struct {
  158.     char *Systemname;
  159.     long Date;
  160. } SystemRec;
  161.  
  162. /* this structure is used for efficient updates of *.sfl */
  163. typedef struct {
  164.     char *Systemname;
  165.     SListBase NewFiles;    /* but this is just a list of strings */
  166. } SystemUpdate;
  167.  
  168. /*
  169.  * ParseFileMap()
  170.  *
  171.  * This function will read in CtdlAff.Sys.
  172.  */
  173. void ParseFileMap()
  174. {
  175.     SYS_FILE fn;
  176.  
  177.     makeSysName(fn, "ctdlaff.sys", &cfg.netArea);
  178.     if (!MakeList(&Files, fn, NULL))
  179.     crashout("Couldn't find CtdlAff.Sys.");
  180. }
  181.  
  182. /*
  183.  * EatMapLine()
  184.  *
  185.  * This function will eat a line from a file map.  Actions depend on
  186.  * MapState:
  187.  *
  188.  *    FILE_NAME: looking for a filename to parse.
  189.  *    SYSTEM_NAME: looking for a system to send file to.
  190.  *    NO_FILE_NAME: File for this doesn't exist, so ignore entries.
  191.  *
  192.  *    File is formatted:
  193.  *    <filename>
  194.  *    <system name>:<number>
  195.  *    <system name>:<number>
  196.  *    ...
  197.  *    <blank line>
  198.  *    <filename>
  199.  */
  200. void *EatMapLine(char *line)
  201. {
  202.     static FileList *data;    /* keep static so we know what's current*/
  203.     char *colon, work[200];
  204.     SystemRec *sysdata;
  205.     SystemUpdate *sysupdate, *System;
  206. #ifndef NO_STAT
  207.     struct stat buf;
  208. #endif
  209.  
  210.     switch (MapState) {
  211.     case FILE_NAME:
  212.     if (strLen(line) == 0) return NULL;    /* discard blank lines    */
  213.     if (access(line, 0) != 0) {        /* if file doesn't exist*/
  214.         MapState = NO_FILE_NAME;        /* then don't process    */
  215.         printf("Warning: file %s not found.\n", line);
  216.     }
  217.     else MapState = SYSTEM_NAME;    /* file exists */
  218.     data = GetDynamic(sizeof *data);
  219.     data->Filename = strdup(line);
  220.     if (MapState == SYSTEM_NAME) {
  221. #ifndef NO_STAT
  222.         stat(line, &buf);
  223.         data->Date = buf.st_mtime;
  224. #else
  225.         data->Date = getdateof(line);
  226. #endif
  227.     }
  228.     InitListValues(&data->SystemList, NULL, NULL, NULL, NULL);
  229.     return data;
  230.     case NO_FILE_NAME:
  231.     if (strLen(line) == 0) {    /* blank line, return to normal */
  232.         MapState = FILE_NAME;
  233.         return NULL;
  234.     }
  235.     if ((colon = strchr(line, ':')) != NULL) {
  236.         *colon++ = 0;
  237.         NormStr(colon);        /* kill leading spaces on date */
  238.         NormStr(line);        /* kill trailing spaces */
  239.         sysdata = GetDynamic(sizeof *sysdata);
  240.         sysdata->Systemname = strdup(line);
  241.         sysdata->Date = atol(colon);
  242.         AddData(&data->SystemList, sysdata, NULL, FALSE);
  243.     }
  244.     return NULL;
  245.     case SYSTEM_NAME:
  246.     if (strLen(line) == 0) {    /* blank line, return to normal */
  247.         MapState = FILE_NAME;
  248.     }
  249.     else {
  250.         if ((colon = strchr(line, ':')) != NULL) {
  251.         *colon++ = 0;
  252.         NormStr(colon);        /* kill leading spaces on date */
  253.         NormStr(line);        /* kill trailing spaces */
  254.         sysdata = GetDynamic(sizeof *sysdata);
  255.         sysupdate = GetDynamic(sizeof *sysupdate);
  256.         sysdata->Systemname = sysupdate->Systemname = strdup(line);
  257.         sysdata->Date = atol(colon);
  258.         AddData(&data->SystemList, sysdata, NULL, FALSE);
  259.         if (data->Date > sysdata->Date) {
  260.             if ((System = SearchList(&Systems, sysdata->Systemname))
  261.                                 == NULL) {
  262.             System = sysupdate;
  263.             InitListValues(&System->NewFiles,NULL,NULL,NULL,NULL);
  264.             AddData(&Systems, System, NULL, FALSE);
  265.             }
  266.             else free(sysupdate);
  267.             strcpy(work, data->Filename);
  268.             AddData(&System->NewFiles, strdup(work), NULL, FALSE);
  269.             if (searchNameNet(line, &netBuf) != ERROR)
  270.             sysdata->Date = data->Date;    /* update record */
  271.         }
  272.         }
  273.     }
  274.     return NULL;            /* always return NULL here    */
  275.     default: crashout("Parsing failure!");
  276.     }
  277.     return NULL;
  278. }
  279.  
  280. static FILE *fd;
  281. /*
  282.  * RewriteFileMap()
  283.  *
  284.  * This function writes out the file map.
  285.  */
  286. void RewriteFileMap()
  287. {
  288.     SYS_FILE fn;
  289.     void WriteFileList();
  290.  
  291.     makeSysName(fn, "ctdlaff.sys", &cfg.netArea);
  292.     if ((fd = fopen(fn, WRITE_TEXT)) == NULL)
  293.     crashout("Couldn't update CtdlAff.Sys!");
  294.     RunList(&Files, WriteFileList);
  295.     fclose(fd);
  296. }
  297.  
  298. /*
  299.  * WriteFileList()
  300.  *
  301.  * This is a work fn that writes out a ctdlaff.sys entry.
  302.  */
  303. void WriteFileList(FileList *data)
  304. {
  305.     void SystemWrite();
  306.  
  307.     fprintf(fd, "%s\n", data->Filename);
  308.     RunList(&data->SystemList, SystemWrite);
  309.     fprintf(fd, "\n");    /* blank line separator */
  310. }
  311.  
  312. /*
  313.  * SystemWrite()
  314.  *
  315.  * This work fn writes out the indicated system to fd.
  316.  */
  317. void SystemWrite(SystemRec *data)
  318. {
  319.     fprintf(fd, "    %s : %ld\n", data->Systemname, data->Date);
  320. }
  321.  
  322. /*
  323.  * SendThemFiles()
  324.  *
  325.  * This function manages setting up the .sfl files.
  326.  */
  327. void SendThemFiles()
  328. {
  329.     void UpdateSFLs();
  330.  
  331.     RunList(&Systems, UpdateSFLs);
  332. }
  333.  
  334. void *FileCmp();
  335. SListBase TempList = { NULL, FileCmp, NULL, NoFree, NULL };
  336. /*
  337.  * UpdateSFLs()
  338.  *
  339.  * This updates the sfl file for the given system.  It works to ensure
  340.  * duplicates are not accidentally sent - that explains the complexity.
  341.  */
  342. void UpdateSFLs(SystemUpdate *data)
  343. {
  344.     void CopyToTemp(), WriteSFL();
  345.     int slot;
  346.     SYS_FILE fn;
  347.     char temp[10], realname[100];
  348.  
  349.     if ((slot = searchNameNet(data->Systemname, &netBuf)) == ERROR) {
  350.         printf("Warning: no system '%s' known.\n", data->Systemname);
  351.         return;
  352.     }
  353.     printf("System %s:", data->Systemname);
  354.     RunList(&data->NewFiles, CopyToTemp);
  355.     printf(".\n");
  356.  
  357.     sPrintf(temp, "%d.sfl", slot);
  358.     makeSysName(fn, temp, &cfg.netArea);
  359.  
  360.     if ((upfd = safeopen(fn, READ_ANY)) != NULL) {
  361.         while (getSLNet(realname, upfd)) {
  362.             /* NormalName(&buf, realname); */
  363.             AddData(&TempList, strdup(realname), NULL, TRUE);
  364.         }
  365.         fclose(upfd);
  366.         unlink(fn);
  367.     }
  368.  
  369.     if ((upfd = safeopen(fn, WRITE_ANY)) != NULL) {
  370.         RunList(&TempList, WriteSFL);
  371.         fclose(upfd);
  372.     }
  373.  
  374.     netBuf.nbflags.send_files = TRUE;
  375.     putNet(slot, &netBuf);
  376.     KillList(&TempList);
  377. }
  378.  
  379. /*
  380.  * WriteSFL()
  381.  *
  382.  * This will update the .sfl file.
  383.  */
  384. void WriteSFL(char *name)
  385. {
  386.     struct fl_send buf;
  387.     void SetBuffer(char *name, struct fl_send *buf);
  388.  
  389.     SetBuffer(name, &buf);
  390.     putSLNet(buf, upfd);
  391. }
  392.  
  393. /*
  394.  * CopyToTemp()
  395.  *
  396.  * This function will copy a name to the temporary list with no dups.
  397.  */
  398. void CopyToTemp(char *name)
  399. {
  400.     printf(" %s", name);
  401.     AddData(&TempList, name, NULL, TRUE);
  402. }
  403.  
  404. /*
  405.  * ShowArguments()
  406.  *
  407.  * This will show off arguments.
  408.  */
  409. void ShowArguments()
  410. {
  411.     printf("usage: Aff\n");
  412. }
  413.  
  414. /*
  415.  * FileCmp()
  416.  *
  417.  * This function helps find the designated string in a list of strings.
  418.  */
  419. void *FileCmp(char *n1, char *n2)
  420. {
  421.     if (strCmpU(n1, n2) == SAMESTRING) return n1;
  422.     return NULL;
  423. }
  424.  
  425. /*
  426.  * CheckSystems()
  427.  *
  428.  * This function is used to help search for a given system in a list.
  429.  */
  430. void *CheckSystems(SystemRec *s, char *t)
  431. {
  432.     if (stricmp(s->Systemname, t) == SAMESTRING) return s;
  433.     return NULL;
  434. }
  435.  
  436. long getdateof(char *file)
  437.   {
  438.   long thetime;
  439.   struct FileInfoBlock *info;
  440.   info = (struct FileInfoBlock *)calloc(1, sizeof(struct FileInfoBlock));
  441.   if( dfind(info,file,0) == 0 )
  442.     {
  443.     thetime = info->fib_Date.ds_Days*24*3600;
  444.     thetime+= info->fib_Date.ds_Minute;
  445.     }
  446.   else  thetime = 0;
  447.   free(info);
  448.   return thetime;
  449.   }
  450.